home *** CD-ROM | disk | FTP | other *** search
/ AmigActive 25 / AACD 25.iso / AACD / Magazine / Backups / FBackNG / fbackngui.c < prev    next >
Encoding:
C/C++ Source or Header  |  2001-08-30  |  28.7 KB  |  639 lines
  1. /* StormC
  2.    FBackNGUI
  3.    ©1999 Visionary Software - All rights reserved
  4.    Program by Chris De Maeyer
  5. */
  6.  
  7. #include        <stdio.h>
  8. #include        <string.h>
  9.  
  10. #include        <dos/dos.h>
  11. #include        <dos/dostags.h>
  12. #include        <clib/alib_protos.h>
  13. #include        <pragma/exec_lib.h>
  14. #include        <pragma/dos_lib.h>
  15. #include        <pragma/intuition_lib.h>
  16. #include        <pragma/utility_lib.h>
  17. #include        <pragma/asl_lib.h>
  18. #include        <pragma/wizard_lib.h>
  19. #include        <libraries/wizard.h>
  20. #include        <intuition/gadgetclass.h>
  21. #include        <intuition/intuition.h>
  22.  
  23. #include        "fbackngui.h"
  24. #include        "options.h"
  25. #include        "config.h"
  26.  
  27. char version[]="$VER: FBackNGUI V1.1 ";
  28. APTR                      surface;
  29. struct Screen             *screen;
  30. struct NewWindow          *newwin,*infowin;
  31. struct Window             *window,*infowindow;
  32. struct WizardWindowHandle *winhandle,*infohandle;
  33. struct Gadget             *gads[MAIN_WIN_GADGETS];
  34. struct Gadget             *iads[INFO_WIN_GADGETS];
  35.  
  36. struct FileRequester      *filereq;
  37. OPTS                      opt;
  38. char                      file[STR_LONG];
  39. char                      *autocon="CON:0/40/640/150/FBackNG-Shell/auto/close";
  40. char                      *temp = NULL;
  41.  
  42. #ifndef __STORM__
  43. struct Library            *AslBase;
  44. struct Library            *IntuitionBase;
  45. struct Library            *WizardBase;
  46.  
  47. int init_libraries( void);
  48. void exit_libraries( void);
  49. #endif
  50.  
  51. LONG beginCommand(char *command)
  52. {
  53.     struct TagItem stags[5];
  54.     BPTR file;
  55.  
  56.     if(file= Open(autocon,MODE_OLDFILE))
  57.     {
  58.         stags[0].ti_Tag=SYS_Input;
  59.         stags[0].ti_Data=file;
  60.  
  61.         stags[1].ti_Tag=SYS_Output;
  62.         stags[1].ti_Data=NULL;
  63.  
  64.         stags[2].ti_Tag=SYS_Asynch;
  65.         stags[2].ti_Data=FALSE;
  66.  
  67.         stags[3].ti_Tag=SYS_UserShell;
  68.         stags[3].ti_Data=TRUE;
  69.  
  70.         stags[4].ti_Tag=TAG_DONE;
  71.         return(System(command, stags));
  72.     }
  73.     else
  74.         return(-2);
  75. }
  76.  
  77. BOOL CheckMyDate(char *date)
  78. {
  79.     struct DateTime dt;
  80.  
  81.     dt.dat_Format  = FORMAT_DOS;
  82.     dt.dat_StrDate = date;
  83.     dt.dat_StrTime = NULL;
  84.     dt.dat_Flags   = 0L;
  85.     dt.dat_StrDay  = NULL;
  86.  
  87.     if(!(StrToDate(&dt)))
  88.         return(FALSE);
  89.     return(TRUE);
  90. }
  91.  
  92. void GetValues(void)
  93. {
  94.     ULONG *itemp = NULL;
  95.  
  96.     // CheckBoxes already toggled by main
  97.  
  98.     GetAttr(WSTRINGA_String, gads[STR_SOURCE], (ULONG *)&temp);
  99.     strncpy(opt.source, temp, STR_LONG);
  100.     GetAttr(WSTRINGA_String, gads[STR_DEST], (ULONG *)&temp);
  101.     strncpy(opt.dest, temp, STR_LONG);
  102.     GetAttr(WSTRINGA_String, gads[STR_LOG], (ULONG *)&temp);
  103.     strncpy(opt.log, temp, STR_LONG);
  104.     GetAttr(WSTRINGA_String, gads[STR_TO], (ULONG *)&temp);
  105.     strncpy(opt.to, temp, STR_SHORT);
  106.     GetAttr(WSTRINGA_String, gads[STR_FROM], (ULONG *)&temp);
  107.     strncpy(opt.from, temp, STR_SHORT);
  108.     GetAttr(WSTRINGA_String, gads[STR_PACKER], (ULONG *)&temp);
  109.     strncpy(opt.packer, temp, STR_SHORT);
  110.     GetAttr(WSTRINGA_String, gads[STR_PATTERN], (ULONG *)&temp);
  111.     strncpy(opt.pattern, temp, STR_SHORT);
  112.  
  113.     GetAttr(WCHECKBOXA_Checked, gads[CHK_BACKUP], itemp);
  114.     opt.backup=(BOOL)*itemp;
  115.     GetAttr(WCHECKBOXA_Checked, gads[CHK_MIRROR], itemp);
  116.     opt.mirror=(BOOL)*itemp;
  117.     GetAttr(WCHECKBOXA_Checked, gads[CHK_DELETE], itemp);
  118.     opt.delete=(BOOL)*itemp;
  119.     GetAttr(WCHECKBOXA_Checked, gads[CHK_RECURS], itemp);
  120.     opt.recursive=(BOOL)*itemp;
  121.     GetAttr(WCHECKBOXA_Checked, gads[CHK_TOUCH], itemp);
  122.     opt.touch=(BOOL)*itemp;
  123.     GetAttr(WCHECKBOXA_Checked, gads[CHK_NOTES], itemp);
  124.     opt.notes=(BOOL)*itemp;
  125.     GetAttr(WCHECKBOXA_Checked, gads[CHK_SIMUL], itemp);
  126.     opt.simulate=(BOOL)*itemp;
  127.     GetAttr(WCHECKBOXA_Checked, gads[CHK_EVERY], itemp);
  128.     opt.every=(BOOL)*itemp;
  129.     GetAttr(WCHECKBOXA_Checked, gads[CHK_NARCHIV], itemp);
  130.     opt.narchiv=(BOOL)*itemp;
  131.  
  132.     GetAttr(WCYCLEA_Active,gads[CYC_VERBOSE], itemp);
  133.     opt.verbosity=(int)*itemp;
  134.  
  135.     GetAttr(WSLIDERA_Level,gads[HSL_PRI], itemp);
  136.     opt.priority=(int)*itemp;
  137.  
  138. }
  139.  
  140. void SavePrefs(char *file)
  141. {
  142.     long result;
  143.  
  144.     result = WriteConfig(file,"FBackNGui", "SourcePath", opt.source);
  145.     result = WriteConfig(file,"FBackNGui", "DestPath", opt.dest);
  146.     result = WriteConfig(file,"FBackNGui", "LogFile", opt.log);
  147.     result = WriteConfig(file,"FBackNGui", "Packer", opt.packer);
  148.     result = WriteConfig(file,"FBackNGui", "FromDate", opt.from);
  149.     result = WriteConfig(file,"FBackNGui", "ToDate", opt.to);
  150.     result = WriteConfig(file,"FBackNGui", "Pattern", opt.pattern);
  151.  
  152.     result = WriteConfigNumber(file,"FBackNGui", "Backup", opt.backup);
  153.     result = WriteConfigNumber(file,"FBackNGui", "Mirror", opt.mirror);
  154.     result = WriteConfigNumber(file,"FBackNGui", "Delete", opt.delete);
  155.     result = WriteConfigNumber(file,"FBackNGui", "Recursive", opt.recursive);
  156.     result = WriteConfigNumber(file,"FBackNGui", "Every", opt.every);
  157.     result = WriteConfigNumber(file,"FBackNGui", "Touch", opt.touch);
  158.     result = WriteConfigNumber(file,"FBackNGui", "NoNotes", opt.notes);
  159.     result = WriteConfigNumber(file,"FBackNGui", "Simulate", opt.simulate);
  160.     result = WriteConfigNumber(file,"FBackNGui", "Priority", opt.priority);
  161.     result = WriteConfigNumber(file,"FBackNGui", "Verbosity", opt.verbosity);
  162.     result = WriteConfigNumber(file,"FBackNGui", "NoArchiv", opt.narchiv);
  163. }
  164.  
  165. void LoadPrefs(char *file)
  166. {
  167.     long result;
  168.  
  169.     result = ReadConfig(file,"FBackNGui", "SourcePath", (char *)opt.source, STR_LONG, "");
  170.     result = ReadConfig(file,"FBackNGui", "DestPath", (char *)opt.dest, STR_LONG, "");
  171.     result = ReadConfig(file,"FBackNGui", "LogFile", (char *)opt.log, STR_LONG, "");
  172.     result = ReadConfig(file,"FBackNGui", "Packer", (char *)opt.packer, STR_SHORT, "");
  173.     result = ReadConfig(file,"FBackNGui", "FromDate", (char *)opt.from, STR_SHORT, "");
  174.     result = ReadConfig(file,"FBackNGui", "ToDate", (char *)opt.to, STR_SHORT, "");
  175.     result = ReadConfig(file,"FBackNGui", "Pattern", (char *)opt.pattern, STR_SHORT, "");
  176.  
  177.     result = ReadConfigNumber(file,"FBackNGui", "Backup", 0);
  178.     opt.backup = result;
  179.     result = ReadConfigNumber(file,"FBackNGui", "Mirror", 0);
  180.     opt.mirror = result;
  181.     result = ReadConfigNumber(file,"FBackNGui", "Mirror", 0);
  182.     opt.mirror = result;
  183.     result = ReadConfigNumber(file,"FBackNGui", "Delete", 0);
  184.     opt.delete = result;
  185.     result = ReadConfigNumber(file,"FBackNGui", "Recursive", 0);
  186.     opt.recursive = result;
  187.     result = ReadConfigNumber(file,"FBackNGui", "Every", 0);
  188.     opt.every = result;
  189.     result = ReadConfigNumber(file,"FBackNGui", "Touch", 0);
  190.     opt.touch = result;
  191.     result = ReadConfigNumber(file,"FBackNGui", "NoNotes", 0);
  192.     opt.notes = result;
  193.     result = ReadConfigNumber(file,"FBackNGui", "Simulate", 0);
  194.     opt.simulate = result;
  195.     result = ReadConfigNumber(file,"FBackNGui", "Priority", 0);
  196.     opt.priority = result;
  197.     result = ReadConfigNumber(file,"FBackNGui", "Verbosity", 0);
  198.     opt.verbosity = result;
  199.     result = ReadConfigNumber(file,"FBackNGui", "NoArchiv", 0);
  200.     opt.narchiv = result;
  201. }
  202.  
  203. // set gadgets to loaded values
  204. void SetGads(void)
  205. {
  206.     SetGadgetAttrs(gads[STR_SOURCE],window,0L,WSTRINGA_String, opt.source,TAG_DONE);
  207.     SetGadgetAttrs(gads[STR_DEST],window,0L,WSTRINGA_String, opt.dest,TAG_DONE);
  208.     SetGadgetAttrs(gads[STR_LOG],window,0L,WSTRINGA_String, opt.log, TAG_DONE);
  209.     SetGadgetAttrs(gads[STR_TO],window,0L,WSTRINGA_String, opt.to,TAG_DONE);
  210.     SetGadgetAttrs(gads[STR_FROM],window,0L,WSTRINGA_String, opt.from,TAG_DONE);
  211.     SetGadgetAttrs(gads[STR_PACKER],window,0L,WSTRINGA_String, opt.packer,TAG_DONE);
  212.     SetGadgetAttrs(gads[STR_PATTERN],window,0L,WSTRINGA_String, opt.pattern,TAG_DONE);
  213.     SetGadgetAttrs(gads[HSL_PRI],window,0L,WSLIDERA_Level,opt.priority,TAG_DONE);
  214.     SetGadgetAttrs(gads[CYC_VERBOSE],window,0L,WCYCLEA_Active,opt.verbosity,TAG_DONE);
  215.     SetGadgetAttrs(gads[CHK_BACKUP],window,0L,WCHECKBOXA_Checked,opt.backup,TAG_DONE);
  216.     SetGadgetAttrs(gads[CHK_MIRROR],window,0L,WCHECKBOXA_Checked,opt.mirror,TAG_DONE);
  217.     SetGadgetAttrs(gads[CHK_DELETE],window,0L,WCHECKBOXA_Checked,opt.delete,TAG_DONE);
  218.     SetGadgetAttrs(gads[CHK_RECURS],window,0L,WCHECKBOXA_Checked,opt.recursive,TAG_DONE);
  219.     SetGadgetAttrs(gads[CHK_TOUCH],window,0L,WCHECKBOXA_Checked,opt.touch,TAG_DONE);
  220.     SetGadgetAttrs(gads[CHK_NOTES],window,0L,WCHECKBOXA_Checked,opt.notes,TAG_DONE);
  221.     SetGadgetAttrs(gads[CHK_SIMUL],window,0L,WCHECKBOXA_Checked,opt.simulate,TAG_DONE);
  222.     SetGadgetAttrs(gads[CHK_EVERY],window,0L,WCHECKBOXA_Checked,opt.every,TAG_DONE);
  223.     SetGadgetAttrs(gads[CHK_NARCHIV],window,0L,WCHECKBOXA_Checked,opt.narchiv,TAG_DONE);
  224.  
  225. }
  226.  
  227. // set gadgets to loaded values
  228. void ClearGads(void)
  229. {
  230.     SetGadgetAttrs(gads[STR_SOURCE],window,0L,WSTRINGA_String, "",TAG_DONE);
  231.     SetGadgetAttrs(gads[STR_DEST],window,0L,WSTRINGA_String, "",TAG_DONE);
  232.     SetGadgetAttrs(gads[STR_LOG],window,0L,WSTRINGA_String, "", TAG_DONE);
  233.     SetGadgetAttrs(gads[STR_TO],window,0L,WSTRINGA_String, "",TAG_DONE);
  234.     SetGadgetAttrs(gads[STR_FROM],window,0L,WSTRINGA_String, "",TAG_DONE);
  235.     SetGadgetAttrs(gads[STR_PACKER],window,0L,WSTRINGA_String, "",TAG_DONE);
  236.     SetGadgetAttrs(gads[STR_PATTERN],window,0L,WSTRINGA_String, "",TAG_DONE);
  237.     SetGadgetAttrs(gads[HSL_PRI],window,0L,WSLIDERA_Level,0,TAG_DONE);
  238.     SetGadgetAttrs(gads[CYC_VERBOSE],window,0L,WCYCLEA_Active,1,TAG_DONE);
  239.     SetGadgetAttrs(gads[CHK_BACKUP],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  240.     SetGadgetAttrs(gads[CHK_MIRROR],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  241.     SetGadgetAttrs(gads[CHK_DELETE],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  242.     SetGadgetAttrs(gads[CHK_RECURS],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  243.     SetGadgetAttrs(gads[CHK_TOUCH],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  244.     SetGadgetAttrs(gads[CHK_NOTES],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  245.     SetGadgetAttrs(gads[CHK_SIMUL],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  246.     SetGadgetAttrs(gads[CHK_EVERY],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  247.     SetGadgetAttrs(gads[CHK_NARCHIV],window,0L,WCHECKBOXA_Checked,0,TAG_DONE);
  248.  
  249. }
  250.  
  251. // check if there is a default prefsfile and load
  252. void Check_Default(void)
  253. {
  254.     BPTR lock=NULL;
  255.  
  256.     if((lock=Lock(DEF_PREFS,ACCESS_READ)))
  257.     {
  258.         UnLock(lock);
  259.         LoadPrefs(DEF_PREFS);
  260.         SetGads();
  261.     }
  262. }
  263.  
  264. void RunFBackNG(void)
  265. {
  266.     char cmdstr[STR_LONG];
  267.     //char temp[12];
  268.  
  269.     strcpy(cmdstr,"c:FBackNG ");
  270.  
  271.     if(opt.source)
  272.     {
  273.         strcat(cmdstr,"-b ");
  274.         strcat(cmdstr,opt.source);
  275.     }
  276.     if(opt.dest)
  277.     {
  278.         strcat(cmdstr," -o ");
  279.         strcat(cmdstr,opt.dest);
  280.     }
  281.     if(!opt.backup)
  282.     {
  283.         strcat(cmdstr," -k");
  284.     }
  285.     if(opt.mirror)
  286.     {
  287.         strcat(cmdstr," -m");
  288.     }
  289.     if(opt.delete)
  290.     {
  291.         strcat(cmdstr," -d");
  292.     }
  293.     if(opt.recursive)
  294.     {
  295.         strcat(cmdstr," -r");
  296.     }
  297.     if(opt.simulate)
  298.     {
  299.         strcat(cmdstr," -s");
  300.     }
  301.     if(opt.touch)
  302.     {
  303.         strcat(cmdstr," -t");
  304.     }
  305.     if(opt.every)
  306.     {
  307.         strcat(cmdstr," -e");
  308.     }
  309.     if(opt.notes)
  310.     {
  311.         strcat(cmdstr," -n");
  312.     }
  313.     if(opt.narchiv)
  314.     {
  315.         strcat(cmdstr," -u");
  316.     }
  317.  
  318.     if(opt.priority>0)
  319.     {
  320.         strcat(cmdstr," -i");
  321.         sprintf(cmdstr,"%s %ld",cmdstr,opt.priority);
  322.     }
  323.     if(opt.verbosity>0)
  324.     {
  325.         strcat(cmdstr," -v");
  326.         sprintf(cmdstr,"%s %ld",cmdstr,opt.verbosity);
  327.     }
  328.     if(opt.packer[0]!='\0')
  329.     {
  330.         strcat(cmdstr," -c");
  331.         sprintf(cmdstr,"%s %s",cmdstr,opt.packer);
  332.     }
  333.     if(opt.from[0]!='\0')
  334.     {
  335.         strcat(cmdstr," -a");
  336.         sprintf(cmdstr,"%s %s",cmdstr,opt.from);
  337.     }
  338.     if(opt.to[0]!='\0')
  339.     {
  340.         strcat(cmdstr," -y");
  341.         sprintf(cmdstr,"%s %s",cmdstr,opt.to);
  342.     }
  343.     if(opt.log[0]!='\0')
  344.     {
  345.         strcat(cmdstr," -l");
  346.         sprintf(cmdstr,"%s %s",cmdstr,opt.log);
  347.     }
  348.     if(opt.pattern[0]!='\0')
  349.     {
  350.         strcat(cmdstr," -g");
  351.         sprintf(cmdstr,"%s %s",cmdstr,opt.pattern);
  352.     }
  353.  
  354.  
  355.     beginCommand(cmdstr);
  356.     //printf("%s\n",cmdstr);
  357. }
  358.  
  359. void info( void)
  360. {
  361.   BOOL Flag;
  362.   struct IntuiMessage *msg;
  363.  
  364.   if ((infohandle=WZ_AllocWindowHandle(screen,0L,surface,TAG_DONE)))
  365.   {
  366.  
  367.     if ((infowin=WZ_CreateWindowObj(infohandle,INFO_WIN,WWH_GadgetArray,iads,
  368.                                              WWH_GadgetArraySize,sizeof(iads),
  369.                                              TAG_DONE)))
  370.     {
  371.  
  372.        if ((infowindow=WZ_OpenWindow(infohandle,infowin,WA_AutoAdjust,TRUE,TAG_DONE)))
  373.        {
  374.            Flag=TRUE;
  375.  
  376.            do
  377.            {
  378.               WaitPort(infowindow->UserPort);
  379.               if ((msg=(struct IntuiMessage *)GetMsg(infowindow->UserPort)))
  380.               {
  381.                   switch(msg->Class)
  382.                   {
  383.                         case IDCMP_CLOSEWINDOW:
  384.                           {
  385.                              Flag=FALSE;
  386.                           }
  387.                           break;
  388.                   }
  389.                   ReplyMsg((struct Message *)msg);
  390.               }
  391.            }
  392.            while (Flag);
  393.            WZ_CloseWindow(infohandle);
  394.       }
  395.       WZ_FreeWindowHandle(infohandle);
  396.     }
  397.   }
  398. }
  399.  
  400. void main( void)
  401. {
  402.         BOOL Flag;
  403.         int gid;
  404.         struct IntuiMessage *msg;
  405.  
  406.         #ifndef __STORM__
  407.         if(! init_libraries( ))
  408.                 return;
  409.         #endif
  410.  
  411.  
  412.         if ((surface=WZ_OpenSurface("fbackngui.wizard",0L,TAG_DONE)))
  413.         {
  414.  
  415.                 if ((screen=LockPubScreen( 0L)))
  416.                 {
  417.  
  418.                         if ((winhandle=WZ_AllocWindowHandle(screen,0L,surface,TAG_DONE)))
  419.                         {
  420.  
  421.                                 if ((newwin=WZ_CreateWindowObj(winhandle,MAIN_WIN,WWH_GadgetArray,gads,
  422.                                                                 WWH_GadgetArraySize,sizeof(gads),TAG_DONE)))
  423.                                 {
  424.  
  425.                                         if ((window=WZ_OpenWindow(winhandle,newwin,WA_AutoAdjust,TRUE,TAG_DONE)))
  426.                                         {
  427.                                                 Flag=TRUE;
  428.  
  429.                                                 HelpControl(window,HC_GADGETHELP);
  430.  
  431.                                                 Check_Default();
  432.  
  433.                                                 do
  434.                                                 {
  435.                                                         WaitPort(window->UserPort);
  436.  
  437.                                                         if ((msg=(struct IntuiMessage *)GetMsg(window->UserPort)))
  438.                                                         {
  439.  
  440.  
  441.                                                                 switch(msg->Class)
  442.                                                                 {
  443.                                                                         case IDCMP_CLOSEWINDOW:
  444.                                                                         {
  445.                                                                             Flag=FALSE;
  446.                                                                         }
  447.                                                                         break;
  448.  
  449.                                                                         case IDCMP_GADGETHELP:
  450.                                                                         {
  451.                                                                             if(msg->IAddress)
  452.                                                                             {
  453.                                                                                 SetWindowTitles(window, WZ_GadgetHelp(winhandle, msg->IAddress), (STRPTR)-1L);
  454.                                                                             }
  455.                                                                             else
  456.                                                                                 SetWindowTitles(window, "FBackNGui", (STRPTR)-1L);
  457.                                                                         }
  458.                                                                         break;
  459.  
  460.                                                                         case IDCMP_IDCMPUPDATE:
  461.                                                                         {
  462.  
  463.                                                                           gid = GetTagData(GA_ID,0,(struct TagItem *)msg->IAddress);
  464.                                                                           switch(gid)
  465.                                                                           {
  466.                                                                               case STR_TO:
  467.                                                                                     GetAttr(WSTRINGA_String, gads[STR_TO], (ULONG *)&temp);
  468.                                                                                     strncpy(opt.to, temp, STR_SHORT);
  469.                                                                                     if(!(CheckMyDate(opt.to)))
  470.                                                                                     {
  471.                                                                                         SetGadgetAttrs(gads[STR_TO],window,0L,WSTRINGA_String,"",TAG_DONE);
  472.                                                                                         DisplayBeep(screen);
  473.                                                                                     }
  474.                                                                                     break;
  475.  
  476.                                                                               case STR_FROM:
  477.                                                                                     GetAttr(WSTRINGA_String, gads[STR_FROM], (ULONG *)&temp);
  478.                                                                                     strncpy(opt.from, temp, STR_SHORT);
  479.                                                                                     if(!(CheckMyDate(opt.from)))
  480.                                                                                     {
  481.                                                                                         SetGadgetAttrs(gads[STR_FROM],window,0L,WSTRINGA_String,"",TAG_DONE);
  482.                                                                                         DisplayBeep(screen);
  483.                                                                                     }
  484.                                                                                     break;
  485.  
  486.                                                                               case VBU_DEST:
  487.                                                                               case VBU_SOURCE:
  488.                                                                                        if((filereq=AllocAslRequestTags(ASL_FileRequest,
  489.                                                                                                    ASLFR_Screen, screen,
  490.                                                                                                    ASLFR_DrawersOnly, TRUE,
  491.                                                                                                    TAG_DONE)))
  492.                                                                                        {
  493.                                                                                            WZ_LockWindow(winhandle);
  494.                                                                                            if(AslRequest(filereq,TAG_DONE))
  495.                                                                                            {
  496.                                                                                                if(gid == VBU_SOURCE)
  497.                                                                                                    SetGadgetAttrs(gads[STR_SOURCE],window,0L,WSTRINGA_String,(STRPTR)filereq->rf_Dir,TAG_DONE);
  498.                                                                                                else
  499.                                                                                                    SetGadgetAttrs(gads[STR_DEST],window,0L,WSTRINGA_String,(STRPTR)filereq->rf_Dir,TAG_DONE);
  500.  
  501.                                                                                            }
  502.                                                                                            WZ_UnlockWindow(winhandle);
  503.  
  504.                                                                                            FreeAslRequest(filereq);
  505.                                                                                        }
  506.                                                                                        break;
  507.  
  508.                                                                               case VBU_LOG:
  509.                                                                                        if((filereq=AllocAslRequestTags(ASL_FileRequest,
  510.                                                                                                    ASLFR_Screen, screen,
  511.                                                                                                    TAG_DONE)))
  512.                                                                                        {
  513.                                                                                            WZ_LockWindow(winhandle);
  514.                                                                                            if(AslRequest(filereq,TAG_DONE))
  515.                                                                                            {
  516.                                                                                               strcpy(opt.log,(STRPTR)filereq->rf_Dir);
  517.                                                                                               AddPart(opt.log,(STRPTR)filereq->rf_File,STR_LONG);
  518.                                                                                               SetGadgetAttrs(gads[STR_LOG],window,0L,WSTRINGA_String,opt.log,TAG_DONE);
  519.                                                                                            }
  520.                                                                                            WZ_UnlockWindow(winhandle);
  521.  
  522.                                                                                            FreeAslRequest(filereq);
  523.                                                                                        }
  524.                                                                                        break;
  525.  
  526.                                                                               case BUT_INFO:
  527.                                                                                        WZ_LockWindow(winhandle);
  528.                                                                                        info();
  529.                                                                                        WZ_UnlockWindow(winhandle);
  530.                                                                                        break;
  531.  
  532.                                                                               case BUT_LOAD:
  533.                                                                                        if((filereq=AllocAslRequestTags(ASL_FileRequest,
  534.                                                                                                    ASLFR_Screen, screen,
  535.                                                                                                    TAG_DONE)))
  536.                                                                                        {
  537.                                                                                            WZ_LockWindow(winhandle);
  538.                                                                                            if(AslRequest(filereq,TAG_DONE))
  539.                                                                                            {
  540.                                                                                               strcpy(file,(STRPTR)filereq->rf_File);
  541.                                                                                            }
  542.                                                                                            WZ_UnlockWindow(winhandle);
  543.  
  544.                                                                                            FreeAslRequest(filereq);
  545.                                                                                        }
  546.                                                                                        LoadPrefs(file);
  547.                                                                                        SetGads();
  548.                                                                                        break;
  549.  
  550.                                                                               case BUT_SAVE:
  551.                                                                                        GetValues();
  552.                                                                                        if((filereq=AllocAslRequestTags(ASL_FileRequest,
  553.                                                                                                    ASLFR_Screen, screen,
  554.                                                                                                    TAG_DONE)))
  555.                                                                                        {
  556.                                                                                            WZ_LockWindow(winhandle);
  557.                                                                                            if(AslRequest(filereq,TAG_DONE))
  558.                                                                                            {
  559.                                                                                               strcpy(file,(STRPTR)filereq->rf_File);
  560.                                                                                            }
  561.                                                                                            WZ_UnlockWindow(winhandle);
  562.  
  563.                                                                                            FreeAslRequest(filereq);
  564.                                                                                        }
  565.  
  566.                                                                                        SavePrefs(file);
  567.                                                                                        break;
  568.  
  569.                                                                               case BUT_RUN:
  570.                                                                                        WZ_LockWindow(winhandle);
  571.                                                                                        GetValues();
  572.                                                                                        RunFBackNG();
  573.                                                                                        WZ_UnlockWindow(winhandle);
  574.                                                                                        break;
  575.  
  576.                                                                               case BUT_CLEAR:
  577.                                                                                        ClearGads();
  578.                                                                                        break;
  579.  
  580.                                                                               case BUT_EXIT:
  581.                                                                                     {
  582.                                                                                        Flag=FALSE;
  583.                                                                                     }
  584.                                                                                     break;
  585.  
  586.                                                                               default:
  587.                                                                                     break;
  588.                                                                           }
  589.                                                                         }
  590.                                                                 }
  591.  
  592.                                                                 ReplyMsg((struct Message *)msg);
  593.                                                         }
  594.                                                 }
  595.                                                 while (Flag);
  596.  
  597.  
  598.                                                 WZ_CloseWindow(winhandle);
  599.                                         }
  600.                                 }
  601.  
  602.  
  603.  
  604.                                 WZ_FreeWindowHandle(winhandle);
  605.                         }
  606.  
  607.  
  608.                         UnlockPubScreen(0L,screen);
  609.                 }
  610.  
  611.  
  612.                 WZ_CloseSurface(surface);
  613.         }
  614.         #ifndef __STORM__
  615.         exit_libraries();
  616.         #endif
  617. }
  618.  
  619. #ifndef __STORM__
  620. int init_libraries( void)
  621. {
  622.  
  623. if(! (IntuitionBase = (struct Library *)OpenLibrary("intuition.library",37L)))
  624.         return 0;
  625.  
  626. if(! (WizardBase = (struct Library *)OpenLibrary("wizard.library",37L)))
  627.         return 0;
  628.  
  629. return 1;
  630. }
  631.  
  632. void exit_libraries( void)
  633. {
  634.  
  635. CloseLibrary((struct Library *) WizardBase);
  636. CloseLibrary((struct Library *) IntuitionBase);
  637. }
  638. #endif
  639.